// src/stores/cart.js
import { defineStore } from 'pinia'
import {
  getCartList,
  addToCart,
  updateCartQuantity,
  updateCartSelection,
  clearCart
} from '@/api/index'

const isSuccess = (res) => res && (res.code === 0 || res.code === 200)

export const useCartStore = defineStore('cart', {
  state: () => ({
    items: [],
    summary: {
      totalQuantity: 0,
      selectedCount: 0,
      selectedAmount: 0
    },
    loading: false,
    error: null
  }),

  getters: {
    // 计算选中的商品列表
    selectedItems: (state) => {
      return state.items.filter(item => item.selected)
    },
    
    // 计算总价
    totalPrice: (state) => {
      return state.items.reduce((sum, item) => {
        if (item.selected) {
          return sum + (item.unitPrice * item.quantity)
        }
        return sum
      }, 0)
    }
  },

  actions: {
    /**
     * 从后端获取购物车列表
     */
    async fetchCartItems() {
      this.loading = true
      this.error = null
      try {
        const res = await getCartList()
        if (isSuccess(res)) {
          this.items = res.data.items || []
          this.summary = res.data.summary || {
            totalQuantity: 0,
            selectedCount: 0,
            selectedAmount: 0
          }
        } else {
          this.error = res.message || '获取购物车列表失败'
          console.error('获取购物车失败:', res)
        }
      } catch (error) {
        this.error = error.message || '网络错误'
        console.error('获取购物车异常:', error)
      } finally {
        this.loading = false
      }
    },

    /**
     * 更新本地购物车商品信息，保持原有顺序
     * @param {string} productId - 商品ID
     * @param {object} updates - 要更新的字段
     */
    updateLocalItem(productId, updates) {
      const itemIndex = this.items.findIndex(item => item.productId === productId)
      if (itemIndex !== -1) {
        // 直接更新现有商品，保持顺序不变
        this.items[itemIndex] = { ...this.items[itemIndex], ...updates }
      }
    },

    /**
     * 添加商品到购物车
     * @param {string} productId - 商品ID
     * @param {number} quantity - 数量，默认为1
     */
    async addItem(productId, quantity = 1) {
      this.loading = true
      this.error = null
      try {
        const res = await addToCart({ productId, quantity })
        if (isSuccess(res)) {
          // 添加成功后重新获取购物车列表
          await this.fetchCartItems()
          return true
        } else {
          this.error = res.message || '添加商品失败'
          console.error('添加商品到购物车失败:', res)
          return false
        }
      } catch (error) {
        this.error = error.message || '网络错误'
        console.error('添加商品到购物车异常:', error)
        return false
      } finally {
        this.loading = false
      }
    },

    /**
     * 更新购物车商品数量
     * @param {string} productId - 商品ID
     * @param {number} quantity - 新的数量
     */
    async updateQuantity(productId, quantity) {
      this.loading = true
      this.error = null
      
      // 如果数量为0，表示删除商品，需要重新获取列表
      if (quantity === 0) {
        try {
          const res = await updateCartQuantity(productId, { quantity })
          if (isSuccess(res)) {
            await this.fetchCartItems()
            return true
          } else {
            this.error = res.message || '更新商品数量失败'
            console.error('更新商品数量失败:', res)
            return false
          }
        } catch (error) {
          this.error = error.message || '网络错误'
          console.error('更新商品数量异常:', error)
          return false
        } finally {
          this.loading = false
        }
      }
      
      // 对于非删除操作，先更新本地状态，再同步到后端
      const originalItem = this.items.find(item => item.productId === productId)
      if (!originalItem) {
        this.loading = false
        this.error = '商品不存在'
        return false
      }
      
      const originalQuantity = originalItem.quantity
      
      try {
        // 先更新本地状态，保持顺序
        this.updateLocalItem(productId, { quantity })
        
        // 同步到后端
        const res = await updateCartQuantity(productId, { quantity })
        if (isSuccess(res)) {
          // 更新成功，保持本地状态
          return true
        } else {
          // 更新失败，恢复本地状态
          this.updateLocalItem(productId, { quantity: originalQuantity })
          this.error = res.message || '更新商品数量失败'
          console.error('更新商品数量失败:', res)
          return false
        }
      } catch (error) {
        // 异常情况，恢复本地状态
        this.updateLocalItem(productId, { quantity: originalQuantity })
        this.error = error.message || '网络错误'
        console.error('更新商品数量异常:', error)
        return false
      } finally {
        this.loading = false
      }
    },

    /**
     * 切换商品选中状态
     * @param {string} productId - 商品ID
     * @param {boolean} selected - 是否选中
     * @param {boolean} skipRefresh - 是否跳过刷新（批量操作时使用）
     */
    async toggleSelection(productId, selected, skipRefresh = false) {
      if (!skipRefresh) {
        this.loading = true
      }
      this.error = null
      
      const originalItem = this.items.find(item => item.productId === productId)
      if (!originalItem) {
        if (!skipRefresh) {
          this.loading = false
        }
        this.error = '商品不存在'
        return false
      }
      
      const originalSelected = originalItem.selected
      
      try {
        // 先更新本地状态，保持顺序
        this.updateLocalItem(productId, { selected })
        
        // 同步到后端
        const res = await updateCartSelection(productId, { selected })
        if (isSuccess(res)) {
          // 更新成功，保持本地状态
          return true
        } else {
          // 更新失败，恢复本地状态
          this.updateLocalItem(productId, { selected: originalSelected })
          this.error = res.message || '更新选中状态失败'
          console.error('更新选中状态失败:', res)
          return false
        }
      } catch (error) {
        // 异常情况，恢复本地状态
        this.updateLocalItem(productId, { selected: originalSelected })
        this.error = error.message || '网络错误'
        console.error('更新选中状态异常:', error)
        return false
      } finally {
        if (!skipRefresh) {
          this.loading = false
        }
      }
    },

    /**
     * 删除购物车商品（通过将数量设为0实现）
     * @param {string} productId - 商品ID
     */
    async removeItem(productId) {
      return await this.updateQuantity(productId, 0)
    },

    /**
     * 批量删除选中的商品
     */
    async removeSelectedItems() {
      if (this.selectedItems.length === 0) {
        return true
      }
      
      this.loading = true
      this.error = null
      try {
        const selectedItems = [...this.selectedItems] // 创建副本，避免在删除过程中数组变化
        
        // 批量删除，使用 Promise.all 并发执行
        const promises = selectedItems.map(item => 
          updateCartQuantity(item.productId, { quantity: 0 })
        )
        await Promise.all(promises)
        
        // 所有删除完成后，刷新购物车
        await this.fetchCartItems()
        return true
      } catch (error) {
        this.error = error.message || '网络错误'
        console.error('批量删除商品异常:', error)
        return false
      } finally {
        this.loading = false
      }
    },

    /**
     * 清空购物车
     */
    async clearAll() {
      this.loading = true
      this.error = null
      try {
        const res = await clearCart()
        if (isSuccess(res)) {
          this.items = []
          this.summary = {
            totalQuantity: 0,
            selectedCount: 0,
            selectedAmount: 0
          }
          return true
        } else {
          this.error = res.message || '清空购物车失败'
          console.error('清空购物车失败:', res)
          return false
        }
      } catch (error) {
        this.error = error.message || '网络错误'
        console.error('清空购物车异常:', error)
        return false
      } finally {
        this.loading = false
      }
    },

    /**
     * 全选/取消全选
     * @param {boolean} selected - 是否选中
     */
    async toggleSelectAll(selected) {
      this.loading = true
      this.error = null
      
      // 保存原始选中状态，以便失败时恢复
      const originalSelectedStates = this.items.map(item => ({
        productId: item.productId,
        selected: item.selected
      }))
      
      try {
        // 先更新本地状态，保持顺序
        this.items.forEach(item => {
          item.selected = selected
        })
        
        // 批量同步到后端
        const promises = this.items.map(item =>
          updateCartSelection(item.productId, { selected })
        )
        const results = await Promise.all(promises)
        
        // 检查是否所有请求都成功
        const allSuccess = results.every(res => isSuccess(res))
        
        if (allSuccess) {
          // 所有更新成功，保持本地状态
          return true
        } else {
          // 有更新失败，恢复本地状态
          originalSelectedStates.forEach(({ productId, selected: originalSelected }) => {
            this.updateLocalItem(productId, { selected: originalSelected })
          })
          this.error = '部分商品选中状态更新失败'
          console.error('全选/取消全选部分失败:', results)
          return false
        }
      } catch (error) {
        // 异常情况，恢复本地状态
        originalSelectedStates.forEach(({ productId, selected: originalSelected }) => {
          this.updateLocalItem(productId, { selected: originalSelected })
        })
        this.error = error.message || '网络错误'
        console.error('全选/取消全选异常:', error)
        return false
      } finally {
        this.loading = false
      }
    }
  }
})
